package com.ruoyi.system.service.impl;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.Device;
import com.ruoyi.system.domain.DeviceDTO;
import com.ruoyi.system.domain.DeviceQueryParams;
import com.ruoyi.system.domain.DeviceView;
import com.ruoyi.system.mapper.AreaMapper;
import com.ruoyi.system.mapper.DeviceMapper;
import com.ruoyi.system.mapper.DeviceTypeMapper;
import com.ruoyi.system.mapper.MineMapper;
import com.ruoyi.system.service.IDeviceService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 设备管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-01-15
 */
@Service
public class DeviceServiceImpl implements IDeviceService 
{
    @Autowired
    private DeviceMapper deviceMapper;
    @Autowired
    private AreaMapper areaMapper;
    @Autowired
    private MineMapper mineMapper;
    @Autowired
    private DeviceTypeMapper deviceTypeMapper;

    /**
     * 查询设备管理
     * 
     * @param deviceId 设备管理主键
     * @return 设备管理
     */
    @Override
    public Device selectDeviceByDeviceId(Long deviceId)
    {
        return deviceMapper.selectDeviceByDeviceId(deviceId);
    }

    /**
     * 查询设备管理
     *
     * @param areaId 设备管理主键
     * @return 设备管理
     */
    @Override
    public List<Device> selectDeviceListByAreaId(Long areaId) {
        return deviceMapper.selectDeviceListByAreaId(areaId);
    }
    /**
     * 查询设备管理
     *
     * @param mineId 设备管理主键
     * @return 设备管理
     */
    @Override
    public List<Device> selectDeviceListByMineId(Long mineId) {
        return deviceMapper.selectDeviceListByMineId(mineId);
    }

    /**
     * 查询设备管理
     *
     * @param deviceTypeId 设备管理主键
     * @return 设备管理
     */
    @Override
    public List<Device> selectDeviceListByDeviceTypeId(Long deviceTypeId) {
        return deviceMapper.selectDeviceListByDeviceTypeId(deviceTypeId);
    }

    /**
     * 查询设备管理列表
     * 
     * @param device 设备管理
     * @return 设备管理
     */
    @Override
    public List<Device> selectDeviceList(Device device)
    {
        return deviceMapper.selectDeviceList(device);
    }

    /**
     * 新增设备管理
     * 
     * @param device 设备管理
     * @return 结果
     */
    @Override
    public int insertDevice(Device device)
    {
        return deviceMapper.insertDevice(device);
    }

    /**
     * 修改设备管理
     * 
     * @param device 设备管理
     * @return 结果
     */
    @Override
    public int updateDevice(Device device)
    {
        return deviceMapper.updateDevice(device);
    }

    /**
     * 批量删除设备管理
     * 
     * @param deviceIds 需要删除的设备管理主键
     * @return 结果
     */
    @Override
    public int deleteDeviceByDeviceIds(Long[] deviceIds)
    {
        return deviceMapper.deleteDeviceByDeviceIds(deviceIds);
    }

    /**
     * 删除设备管理信息
     * 
     * @param deviceId 设备管理主键
     * @return 结果
     */
    @Override
    public int deleteDeviceByDeviceId(Long deviceId)
    {
        return deviceMapper.deleteDeviceByDeviceId(deviceId);
    }

    /**
     * 查询设备总数
     *
     * @return 设备总数
     */
    @Override
    public int selectDeviceCount() {
        return deviceMapper.selectDeviceCount();
    }

    /**
     * 根据状态统计设备数量
     *
     * @param status 设备状态（正常/故障/离线）
     * @return 符合状态的设备总数
     */
    @Override
    public int selectDeviceCountByStatus(String status) {
        return deviceMapper.selectDeviceCountByStatus(status);
    }
    @Override
    public Map<String, Integer> getDeviceStatusCounts() {
        List<Map<String, Object>> result = deviceMapper.selectDeviceCountGroupByStatus();

        Map<String, Integer> statusMap = new LinkedHashMap<>();

        // 动态构建状态统计
        result.forEach(item -> {
            String status = (String) item.get("status");
            Number count = (Number) item.get("count");
            statusMap.put(status, count.intValue());
        });

        return statusMap;
    }

    @Override
    public List<DeviceView> getDeviceView(DeviceQueryParams params) {
        return deviceMapper.selectDeviceView(params);
    }

    @Transactional
    @Override
    public int updateDevice(DeviceDTO dto) {
        // 将视图字段转换为外键ID
        resolveForeignKeys(dto);

        // 将DTO属性拷贝到Device实体
        Device device = new Device();
        BeanUtils.copyProperties(dto, device);

        // 执行更新
        return deviceMapper.updateDevice(device);
    }

    private void resolveForeignKeys(DeviceDTO dto) {
        // 处理区域ID（根据province和city查询）
        if (StringUtils.isNotBlank(dto.getProvince()))
        {
            Long areaId = areaMapper.getAreaIdByNames(dto.getProvince(), dto.getCity());
            if (areaId == null) {
                throw new RuntimeException("区域不存在：" + dto.getProvince() + "-" + dto.getCity());
            }
            dto.setAreaId(areaId);
        }

        // 处理矿山ID（根据mineName查询）
        if (StringUtils.isNotBlank(dto.getMineName())) {
            Long mineId = mineMapper.getMineIdByName(dto.getMineName());
            if (mineId == null) {
                throw new RuntimeException("矿山不存在：" + dto.getMineName());
            }
            dto.setMineId(mineId);
        }

        // 处理设备类型ID（根据typeName查询）
        if (StringUtils.isNotBlank(dto.getTypeName())) {
            Long typeId = deviceTypeMapper.getTypeIdByName(dto.getTypeName());
            if (typeId == null) {
                throw new RuntimeException("设备类型不存在：" + dto.getTypeName());
            }
            dto.setDeviceTypeId(typeId);
        }
    }
}
